'''
本实例中主要使用序列和字典，熟悉相关的数列组合计算方式。
'''
import random
import os
import cn_sequence
red_source=range(1,34) #red ball 范围
blue_source=range(1,17) # blue ball 范围
red_k =[]#[4,8,11,13,17,19,21,22,28,30]
#[4,8,11,13,17,19,21,22,28,30]  # 红杀列表
blue_k=[]#[1,4,6,8,9,10,11,14,]
#[1,4,6,8,9,10,11,14,]  # 篮杀列表
seperation=os.linesep

def coustom_selectnum(selectmax,ball_color):#selectmax 组合可选最大值，ball_color：球的颜色
    print("默认范围内的",ball_color,"ball 组合数：0-",str(selectmax))
    custom_num=input("自定义筛选的组合数量，请输入数字，否则系统默认筛选可能组合的最大值(请直接按enter键。):")
    try:
        if custom_num=="":
            return selectmax
        else:
            custom_num=int(custom_num)
            if custom_num<0:#custom_num>selectmax:自定义筛选次数可以大于总的组合数量次数
                coustom_selectnum(selectmax,ball_color)
    except Exception as e:
        print("请输入正确的数值")
        coustom_selectnum(selectmax,ball_color)
    return custom_num

    
def redsort_num(red_list):
    '''
    返回指定序列中可能的red ball字典
    '''
    red_dic={}  # red {}字典初始化为空字典而不是集合，red_dic=dict()
    item_random={} # 随机数中每个随机数被选中的总次数
    len_redlist=len(red_list)
    sel_max=cn_sequence.select_num(len_redlist,6) #red ball可能的组合数量
    custom_num=coustom_selectnum(sel_max,'red')
    for i in range(1,custom_num+1):
        red_pre=[]
        templist=red_list.copy()
        while(len(red_pre)<6):
            red=random.choice(templist)
            templist.remove(red)
            red_pre.append(red)
            if red not in item_random: #默认字典对象本身可直接获取keys,item_random= item_random.keys()
                item_random[red]=1
            else:
                item_random[red]=item_random[red]+1
        red_dic[i]=sorted(red_pre)
    return (red_dic,item_random)

def bluesort_num(blue_list):
    '''
    #返回指定序列中可能的Bule ball字典
    '''
    blue_dic={}
    item_random={} # 随机数中每个随机数被选中的总次数
    len_bluelist=len(blue_list)
    sel_max=cn_sequence.select_num(len_bluelist,1) #Bule ball可能的组合数量
    custom_num=coustom_selectnum(sel_max,'blue')
    for i in range(1,custom_num+1):
        blue_pre=[]
        templist=blue_list.copy()
        blue=random.choice(templist)
        #templist.remove(blue)
        if blue not in item_random.keys(): #默认字典对象本身可直接获取keys
            item_random[blue]=1
            blue_pre.append(blue)
        else:
            item_random[blue]=item_random[blue]+1
        blue_dic[i]=sorted(blue_pre)
    #print(item_random)    
    return (blue_dic,item_random)

def random_SSQ(red_list,blue_list): # 从指定的红、蓝列表中产生一组SSQ
    '''
    red_list-> red ball list
    blue_list-> blue ball list
    '''
    red_pre=[] #red balll list
    result_dic={}
    while(len(red_pre)<6): # create a random red ball list
        red=random.choice(red_list)
        if red not in red_pre:
            red_pre.append(red)
          
    bluechoice=random.choice(blue_list) #产生篮球，考虑篮球红球不冲突，进行了一下筛选，也可以去掉。
    while(bluechoice in red_pre):
        bluechoice=random.choice(blue_list)
        
    result_dic['R']=sorted(red_pre) #sorted(red_pre)红球排序
    result_dic['B']=bluechoice
    return result_dic

#def more_random_SSQ():
    

def Print_RandomSSQ(dic,sorted_args=False,ballcolor="Red"):
    '''
    print result of  random SSQ
    dic:需要打印的字典源
    ballcolor:球的颜色
    sorted_args:是否需要对字典键值排序,False,不需要,True需要。
    排序功能：利用字典keys可排序功能，先把键值和数值对调后对字典进行排序，然后还原字典输出。
    '''
    print(seperation) #可以直接打印空字符串分割行,也可以直接用print()
    dic_sorted={}  
    dic_keys=list(dic.keys())
    if sorted_args:
        from collections import OrderedDict
        dic_result=OrderedDict()#定义记忆型的字典，可记住items插入的顺序
        cn_sequence.dic_sorted(dic,dic_result) #执行排序操作
        if len(dic_result)>0:
            #dicsorted_keys=sorted(dic_sorted)
            print("{0}数值出现的几率:".format(ballcolor))
            for key in dic_result:
                print('数值:',key,'出现次数:',dic_result[key])# 输出排序后的结果
    else:
        print("here's a prossible group:")
        for key in dic:
            print('key:',key,'value:',dic[key])# 正常输出结果
            
    print()

def main():
    '''
    主模块测试主函数
    '''
    red_templist=[] #pre red temp
    blue_templist=[] #pre blue temp
    blue_pre=[]
    result_dic={}# 产生的SSQ 字典 
    # create red
    for i in red_source:
        if i not in red_k:
            red_templist.append(i)
        
    for i in blue_source:
        if i not in blue_k:
            blue_templist.append(i)
            
    result_dic=random_SSQ(red_templist,blue_templist)
    sel_redballcount=cn_sequence.select_num(len(red_templist),6)
    print("the possible choice of red ball:",sel_redballcount)
    print("the possible choice of blue ball:",len(blue_templist))
    print("the possible choice of SSQ ball:",sel_redballcount*len(blue_templist))
    Print_RandomSSQ(result_dic)
    
    #随机产生一组SSQ
    while (input("press enter to random an another SSQ(press'.' to exit):")!='.'):
        temp=random_SSQ(red_templist,blue_templist)
        Print_RandomSSQ(temp)
        
        
    #所有可能产生的blue ball
    tup_blue=bluesort_num(blue_templist)
    blue_dic=tup_blue[0]
    itemdic_random=tup_blue[1]
    #Print_RandomSSQ(blue_dic)
    Print_RandomSSQ(itemdic_random,True,"Blue")
    
    #所有可能产生的red ball
    #定义tuple(red_dic,item_random) 元组，red_dic字典存储所有red ball组合,itemdic_random字典存储数字被筛选次数
    tup_red=redsort_num(red_templist)
    red_dic=tup_red[0]
    itemdic_random=tup_red[1]
    #Print_RandomSSQ(red_dic)
    Print_RandomSSQ(itemdic_random,True,"Red")
    
    

if __name__=="__main__":
    main()
    
    
